#ifndef MEMORY_POOL_H
#define MEMORY_POOL_H

#include <cstddef>
#include <vector>
#include <mutex>
#include <memory>
#include <functional>

namespace common {
namespace memory {

// 内存块结构
struct MemoryBlock {
    void* data;          // 指向内存块的指针
    bool used;           // 是否被使用
    size_t size;         // 内存块大小
    MemoryBlock* next;   // 下一个内存块

    MemoryBlock(void* ptr, size_t blockSize)
        : data(ptr), used(false), size(blockSize), next(nullptr) {}
};

// 内存池类
class MemoryPool {
public:
    // 创建内存池，指定块大小和初始块数量
    static std::shared_ptr<MemoryPool> create(size_t blockSize, size_t initialBlocks = 16);

    // 析构函数
    ~MemoryPool();

    // 分配内存
    void* allocate();

    // 释放内存
    void deallocate(void* ptr);

    // 获取内存块大小
    size_t getBlockSize() const { return blockSize_; }

    // 获取已分配内存块数
    size_t getAllocatedCount() const { return allocatedCount_; }

    // 获取内存使用率
    float getUsageRatio() const;

    // 打印内存池状态
    void printStatus() const;

private:
    // 私有构造函数
    MemoryPool(size_t blockSize, size_t initialBlocks);

    // 增长内存池
    void grow(size_t blockCount);

    // 查找空闲块
    MemoryBlock* findFreeBlock();

    // 根据数据指针查找内存块
    MemoryBlock* findBlock(void* ptr);

private:
    size_t blockSize_;                   // 内存块大小
    size_t initialBlocks_;               // 初始内存块数量
    size_t allocatedCount_;              // 已分配内存块数
    size_t usedCount_;                   // 已使用内存块数
    std::vector<void*> chunks_;          // 大块内存
    MemoryBlock* freeList_;              // 空闲块链表
    mutable std::mutex mutex_;           // 互斥锁
};

// 智能指针释放器，用于自动归还内存池内存
template<typename T>
class PoolDeleter {
public:
    PoolDeleter(std::shared_ptr<MemoryPool> pool) : pool_(pool) {}

    void operator()(T* ptr) const {
        if (ptr) {
            ptr->~T(); // 显式调用析构函数
            pool_->deallocate(static_cast<void*>(ptr));
        }
    }

private:
    std::shared_ptr<MemoryPool> pool_;
};

// 从内存池创建对象的工厂函数
template<typename T, typename... Args>
std::shared_ptr<T> make_shared_from_pool(std::shared_ptr<MemoryPool> pool, Args&&... args) {
    void* mem = pool->allocate();
    if (!mem) return nullptr;

    // 在分配的内存上原地构造对象
    T* obj = new(mem) T(std::forward<Args>(args)...);
    
    // 创建带自定义删除器的智能指针
    return std::shared_ptr<T>(obj, PoolDeleter<T>(pool));
}

} // namespace memory
} // namespace common

#endif // MEMORY_POOL_H 